package TMS.src;

import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ESC {
    public static void main(String[] args) throws IOException {
        String ret="sucen ffnds,f (O-12378asd)";
        int stIndex = ret.indexOf('O');
        int endIndex = ret.indexOf(')');
        String orderId=ret.substring(stIndex, endIndex);
        System.out.println(orderId);
    }
}
 /*public static void main(String[] args) throws IOException {
        String fileName = "./data";
        File file = new File(fileName);
        if (!file.exists()) {
            //System.out.println("删除文件失败:" + fileName + "不存在！");
        } else {
            if (file.isFile())
                deleteFile(fileName);
            else
                deleteDirectory(fileName);
        }
    }

    *//**
 * 删除单个文件
 *
 * @param fileName：要删除的文件的文件名
 * @return 单个文件删除成功返回true，否则返回false
 * <p>
 * 删除目录及目录下的文件
 * @param dir：要删除的目录的文件路径
 * @return 目录删除成功返回true，否则返回false
 * <p>
 * 删除目录及目录下的文件
 * @param dir：要删除的目录的文件路径
 * @return 目录删除成功返回true，否则返回false
 *//*
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                //System.out.println("删除单个文件" + fileName + "成功！");
                return true;
            } else {
               // System.out.println("删除单个文件" + fileName + "失败！");
                return false;
            }
        } else {
            System.out.println("删除单个文件失败：" + fileName + "不存在！");
            return false;
        }
    }

    *//**
 * 删除目录及目录下的文件
 *
 * @param dir：要删除的目录的文件路径
 * @return 目录删除成功返回true，否则返回false
 *//*
    public static boolean deleteDirectory(String dir) {
        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
        if (!dir.endsWith(File.separator))
            dir = dir + File.separator;
        File dirFile = new File(dir);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
            //System.out.println("删除目录失败：" + dir + "不存在！");
            return false;
        }
        boolean flag = true;
        // 删除文件夹中的所有文件包括子目录
        File[] files = dirFile.listFiles();
        for (File file : files) {
            // 删除子文件
            if (file.isFile()) {
                flag = deleteFile(file.getAbsolutePath());
                if (!flag)
                    break;
            }
            // 删除子目录
            else if (file.isDirectory()) {
                flag = deleteDirectory(file.getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag) {
            //System.out.println("删除目录失败！");
            return false;
        }
        // 删除当前目录
        if (dirFile.delete()) {
            //System.out.println("删除目录" + dir + "成功！");
            return true;
        } else {
            return false;
        }
    }*/
        /*String path="./data/order";
        File file = new File(path, "123123123.txt");//我们在该类的位置创建一个新文件
        File folder=new File(path);
        StringBuilder sb=new StringBuilder();
        FileWriter writer = null;
        for(int i=0; i<path.length(); i++){
            sb.append(path.charAt(i)).append('\n');
        }
        try {
            writer = new FileWriter(file, true);
            writer.append(sb.toString());
            writer.flush();
        } catch (IOException e) {
            System.out.println("记录记录");
            //e.printStackTrace();
        } finally {
            if (null != writer)
                writer.close();
        }*/
       /* String path="./data/order/046418112296.txt";
        File file = new File(path);
        BufferedReader br = new BufferedReader(new FileReader(file));
        StringBuilder out = new StringBuilder();
        String line = null;
        while ((line = br.readLine()) != null) {
            //System.out.println(line);
            out.append(line).append("\n");
        }
        System.out.print(out);
        System.out.println(out);
        br.close();*/
        /*try {
            //这里把文件写入对象和字符流写入对象分开写了
            f = new FileWriter("./data/order"+ "123123123.txt");//创建一个名为cc.txt的文件
            f1 = new BufferedWriter(f);
            //通过循环遍历上面的String 数组中的元素
            for (int i = 0; i < str.length; i++) {
                f1.write(str[i]);//把String中的字符写入文件
                f1.newLine();//换行操作
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {//如果没有catch 异常，程序最终会执行到这里
            try {
                f1.close();
                f.close();//关闭文件
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }*/
        /*String path = "./";
        File f = new File(path, "commodity.txt");
        System.out.println("============================================");
        System.out.println("文件长度：" + f.length() + "字节");
        System.out.println("文件或者目录：" + (f.isFile() ? "是文件" : "不是文件"));
        System.out.println("文件或者目录：" + (f.isDirectory() ? "是目录" : "不是目录"));
        System.out.println("最后修改日期：" + new Date(f.lastModified()));
        System.out.println("文件名称：" + f.getName());
        System.out.println("文件路径：" + f.getPath());
        System.out.println("绝对路径：" + f.getAbsolutePath());
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(f));
            String tempStr = null;
            int line = 1;
            while ((tempStr = reader.readLine()) != null) {
                System.out.println("line" + line + ": " + tempStr);
                line++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {

                }
            }
        }
    }
}*/

/*class Example {
    int id;
    int age;
    String name;

    public Example(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    int getId() {
        return this.id;
    }

    int getAge() {
        return this.age;
    }

    public String toString() {
        return this.age + " " + this.id + " " + this.name + " ";
    }
}

public class ESC {
    public static void main(String[] args) {
        // 需要排序的map集合
        Map<Integer, Example> map = new HashMap<>();
        map.put(1, new Example("张三", 1, 0));
        map.put(2, new Example("李四", 1, 4));
        map.put(3, new Example("刘罗锅", 2, 0));
        map.put(4, new Example("李大爷", 4, 0));
        map.put(5, new Example("王二婶", 7, 9));
        map.put(6, new Example("老王", 3, 10));

        System.out.println("未排序的Map：");
        for (Example e : map.values())
            System.out.println(e);
        //把排序完的linkedHashMap赋值给map1
        List<Map.Entry<Integer, Example>> list =  sort(map);
        System.out.println("排序后的Map：");
        list.forEach(System.out::println);

    }

    // 排序的方法（返回值为HashMap的子类LinkedHashMap； 原因：HashMap无序；LinkedHashMap有序）
    private static List<Map.Entry<Integer, Example>> sort(Map<Integer, Example> map) {
        //先创建一个LinkedHashMap作为返回值
        LinkedHashMap<Integer, Example> linkedHashMap = new LinkedHashMap<>();
        //map.entrySet：就是把(key-value)作为一个整体一对一对地存放到Set集合当中
        Set<Map.Entry<Integer, Example>> entrySet = map.entrySet();
        //ArrayList构造函数接受一个Collection类型的参数，Set是Collection的子类，所以可以把Set对象直接放入转成list
        List<Map.Entry<Integer, Example>> list = new ArrayList<>(entrySet);
        //list对象可以通过sort方法进行排序
        list.sort(new Comparator<Map.Entry<Integer, Example>>() {
            @Override
            public int compare(Map.Entry<Integer, Example> o1, Map.Entry<Integer, Example> o2) {
                // o1-o2是正序；o2-o1是倒序；
                int i = o1.getValue().getAge() - o2.getValue().getAge();
                if (i == 0) { //当i==0时说明上面的排序条件相等了，你可以通过其他条件来排序这个相等的元素；
                    return o1.getValue().getId() - o2.getValue().getId();
                }
                return i;
            }
        });
        return list;
    }
}*/
/*遍历list
import java.util.Arrays;
        import java.util.Iterator;
        import java.util.List;
        import java.util.Objects;
        import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Main {

    public static void main(String[] args) {

        //要遍历的list集合
        List<String> arrays = Arrays.asList("张三", "李四", "王五", "小六", "老七");

        //1. for(int i=0; i< arrays.size(); i++)
        log.info("=================for(int i=0; i< arrays.size(); i++)普通遍历==========");
        for (int i = 0; i < arrays.size(); i++) {
            log.info(arrays.get(i));
        }

        //2. 增强for(String str : arrays)
        log.info("=================增强for(String str : arrays)遍历=====================");
        for (String str : arrays) {
            log.info(str);
        }

        //3. list.forEach((str) -> xxxxx)
        log.info("=================arrays.forEach((str) -> xxxxx)遍历===================");
        arrays.forEach(str -> log.info(str));

        //4. 使用Iterator迭代器遍历
        log.info("=================使用Iterator迭代器遍历================================");
        Iterator<String> it = arrays.iterator();
        while (it.hasNext()) {
            String str = (String) it.next();
            log.info(str);
        }

        //5. java8 stream流遍历
        log.info("=================java8 stream遍历=====================================");
        arrays.stream()
                //过滤掉“王五”
                .filter(str -> !Objects.equals("王五", str))
                .forEach(str -> log.info(str));
    }
}*/


